|
为什么要使用Stream流？
Stream流是JDK1.8更新后带来的新特性，通过将要处理的元素视作为在管道中的流，并进行诸如筛选，排序，分组等等的处理，通过Stream流进行数据处理可以极大的提高程序员的代码编写效率，还能提高代码的简洁度。
如何获取Stream流
获取Stream流的方式主要有以下三种。
通过Collection获取流: Java在Collection接口中提供了default方法，Collection接口的所有实现类都可以通过下面的方式获取Stream流
public class JavaStreamTest01 {
public static void main(String[] args) {
List list = new ArrayList();
Stream stream1 = list.stream();
Set set = new HashSet();
Stream stream2 = set.stream();
Vector vector = new Vector();
Stream stream3 = vector.stream();
}
}
通过Map获取流 Map是以Key-Value的形式来保存数据的，因此也要分3种情况来获取Stream流，分别是Key，Value以及Entry，具体的获取方式如下
public class JavaStreamTest02 {
public static void main(String[] args) {
Map map = new HashMap();
Set key = map.keySet();
Set value = (Set) map.values();
Set entries = map.entrySet();
Stream keyStream = key.stream();
Stream valueStream = value.stream();
Stream entryStream = entries.stream();
}
}
根据数组来获取流 Java中给输注获取流提供了非常简洁的方式，具体的获取方式如下
public class JavaStreamTest03 {
public static void main(String[] args) {
String[] arr=new String[]{"苹果","香蕉","草莓"};
Stream stream = Stream.of(arr);
}
}
常用的对流进行的中间操作
遍历逐一处理（forEach）
public class JavaStreamTest04 {
public static void main(String[] args) {
String[] arr=new String[]{"苹果","香蕉","草莓"};
Stream stream=Stream.of(arr);
stream.forEach(s-> System.out.println(s));
}
}
结果: 
过滤处理（filter）
public class JavaStreamTest05 {
public static void main(String[] args) {
String[] arr=new String[]{"苹果","香蕉","草莓"};
Stream stream=Stream.of(arr);
Stream stream2 = stream.filter(s -> s.startsWith("苹"));
stream2.forEach(s -> System.out.println(s));
}
}
结果: 
映射（map） 将当前流的数据类型映射成另一种数据类型
public class JavaStreamTest06 {
public static void main(String[] args) {
String[] arr=new String[]{"12","33","44"};
Stream stream=Stream.of(arr);
Stream stream2 = stream.map(s -> Integer.parseInt(s));
stream2.forEach(s -> System.out.println(s));
}
}
结果： 
统计流中元素的个数（count）
public class JavaStreamTest07 {
public static void main(String[] args) {
String[] arr=new String[]{"12","33","44"};
Stream stream=Stream.of(arr);
long count = stream.count();
System.out.println(count);
}
}
结果： 
截取特定数量的前几个流元素（limit）
public class JavaStreamTest08 {
public static void main(String[] args) {
String[] arr=new String[]{"12","33","44"};
Stream stream=Stream.of(arr);
Stream limit = stream.limit(2);
limit.forEach(s -> System.out.println(s));
}
}
结果： 
跳过前几个，获取之后的流（skip）
public class JavaStreamTest09 {
public static void main(String[] args) {
String[] arr=new String[]{"12","33","44"};
Stream stream=Stream.of(arr);
Stream skip = stream.skip(2);
skip.forEach(s -> System.out.println(s));
}
}
结果： 
组合流（concat） 当有两个流并希望将他们组合起来时可以使用这个方法
public class JavaStreamTest10 {
public static void main(String[] args) {
String[] arr=new String[]{"12","33","44"};
String[] arr2=new String[]{"苹果","香蕉","草莓"};
Stream stream1=Stream.of(arr);
Stream stream2 = Stream.of(arr2);
Stream concat = Stream.concat(stream1, stream2);
concat.forEach(s -> System.out.println(s));
}
}
结果： 
排序（sorted）
public class JavaStreamTest11 {
public static void main(String[] args) {
String[] arr=new String[]{"张无忌","张三丰","张翠山","张一元"};
Stream stream = Stream.of(arr);
stream.sorted().forEach(s -> System.out.println(s));
}
}
结果： 
去重（distinct） 顾名思义用来去除流中重复的元素
public class JavaStreamTest {
public static void main(String[] args) {
List list=new ArrayList();
list.add(1);
list.add(2);
list.add(1);
list.add(4);
list.add(2);
list.add(6);
Stream stream = list.stream();
stream.distinct().forEach(s-> System.out.println(s));
}
}
结果： 
常用的对Stream流的终结操作
元素收集操作
String[] arr=new String[]{"张无忌","张三丰","张翠山","张一元"};
Stream stream = Stream.of(arr);
//收集到set集合
Set collect = stream.collect(Collectors.toSet());
//收集到list集合
List collect1 = stream.collect(Collectors.toList());
//收集到数组
String[] strings = (String[]) stream.toArray();
查找
public class JavaStreamTest12 {
public static void main(String[] args) {
List list=new ArrayList();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
list.add(6);
Stream stream = list.stream();
Stream stream2 = list.stream();
Stream stream3 = list.stream();
Stream stream4 = list.stream();
//返回流中的第一个元素
int f1 = (int) stream.findFirst().get();
System.out.println(f1);
//返回流中的任意一个元素
int f2 = (int) stream2.findAny().get();
System.out.println(f2);
//返回流中最大的元素
int max = stream3.max((o1, o2) ->o1>o2?1:-1).get();
System.out.println(max);
//返回流中最小元素
int min = stream4.min((o1, o2) -> o1>o2?1:-1).get();
System.out.println(min);
}
}
字符串拼接（joining） 可以将Stream流中的元素通过自定义的规则拼接起来
public class JavaStreamTest13 {
public static void main(String[] args) {
List list = new ArrayList();
list.add("张无忌");
list.add("周芷若");
list.add("赵敏");
list.add("张强");
list.add("张三丰");
System.out.println(list.stream().collect(Collectors.joining(",")));
}
}
结果： 
|